import { defineStore } from 'pinia'
import { ref } from 'vue'
import request from '@/utils/request'
import Layout from '@/layout/index.vue'
import { loadComponent } from '@/utils/componentLoader'

export const useMenuStore = defineStore('menu', () => {
  const menus = ref([])
  const routes = ref([])

  // 获取菜单
  const getMenus = async () => {
    try {
      console.log('开始获取菜单数据...')
      const response = await request.get('/menus/routes/list')
      console.log('菜单API响应:', response)
      if (response && response.code === 200) {
        menus.value = response.data || []
        console.log('菜单数据:', menus.value)
        return menus.value
      } else {
        console.warn('菜单API返回非200状态:', response)
        // 如果返回空数据，使用空数组而不是抛出错误
        menus.value = []
        return []
      }
    } catch (error) {
      console.error('获取菜单失败:', error)
      // 如果请求失败，返回空数组而不是抛出错误，让调用者可以添加默认路由
      menus.value = []
      return []
    }
  }

  // 构建路由（支持最多3级菜单）
  const buildRoutes = (menuList, parentPath = '', level = 1) => {
    const routeList = []
    const maxLevel = 3 // 最多支持3级菜单

    if (level > maxLevel) {
      console.warn(`[RouteBuilder] 菜单层级超过最大限制 ${maxLevel}，跳过`)
      return routeList
    }

    menuList.forEach((menu) => {
      // 跳过按钮类型（type=3）
      if (menu.type === 3) {
        return
      }

      if (menu.type === 1) {
        // 目录（可以是任何级别的父菜单）
        const route = {
          path: menu.path,
          component: Layout,
          meta: {
            title: menu.title,
            icon: menu.icon,
          },
          children: [],
        }

        // 递归处理子菜单（支持多级嵌套）
        if (menu.children && menu.children.length > 0) {
          console.log(`[RouteBuilder] Level ${level}: 处理目录 ${menu.path} 的子菜单，共 ${menu.children.length} 个`)
          const childrenRoutes = buildRoutes(menu.children, menu.path, level + 1)
          route.children = childrenRoutes
          console.log(`[RouteBuilder] Level ${level}: 目录 ${menu.path} 的子路由:`, childrenRoutes.map(r => r.path))
          
          // 设置重定向到第一个可用的子路由（递归查找第一个非目录路由）
          if (childrenRoutes.length > 0) {
            const firstAvailableRoute = findFirstAvailableRoute(childrenRoutes, menu.path)
            if (firstAvailableRoute) {
              route.redirect = firstAvailableRoute
              console.log(`[RouteBuilder] Level ${level}: 目录 ${menu.path} 重定向到: ${firstAvailableRoute}`)
            }
          }
        }

        routeList.push(route)
      } else if (menu.type === 2) {
        // 菜单（可以是2级或3级菜单）
        let componentLoader = null
        if (menu.component) {
          // 处理组件路径
          let componentPath = menu.component
          
          // 如果 component 是 'Layout'，直接使用 Layout 组件
          if (componentPath === 'Layout') {
            componentLoader = Layout
          } else {
            // 使用组件加载器加载组件
            componentLoader = () => loadComponent(componentPath)
          }
        }
        
        // 如果 componentLoader 为 null，使用默认的 404 页面
        if (!componentLoader) {
          componentLoader = () => import('@/views/404.vue')
        }
        
        // 处理路径：如果是子路由，需要转换为相对路径
        // 规则：
        // 1. 如果菜单数据中的 path 是完整路径（如 /system/user），需要根据父路径转换为相对路径
        // 2. 一级菜单：/system -> /system（完整路径）
        // 3. 二级菜单：/system/user，父路径 /system -> user（相对路径，最终路径为 /system/user）
        // 4. 三级菜单：/system/user/user，父路径 /system/user -> user（相对路径，最终路径为 /system/user/user）
        let routePath = menu.path
        let fullPath = menu.path // 保存完整路径，用于递归时传递给子菜单
        
        if (parentPath) {
          // 规范化父路径和子路径
          const normalizedParentPath = parentPath.replace(/\/+$/, '') // 移除尾部斜杠
          const normalizedChildPath = routePath.replace(/\/+$/, '') // 移除尾部斜杠
          
          // 检查子路径是否以父路径开头
          if (normalizedChildPath.startsWith(normalizedParentPath + '/')) {
            // 去掉父路径前缀，转换为相对路径
            // 例如：/system/user -> user (当父路径是 /system 时)
            routePath = normalizedChildPath.substring(normalizedParentPath.length + 1) || 'index'
            fullPath = normalizedChildPath // 保存完整路径
            console.log(`[RouteBuilder] Level ${level}: 子路由路径转换: ${menu.path} (父: ${parentPath}) -> ${routePath} (完整路径: ${fullPath})`)
          } else if (normalizedChildPath === normalizedParentPath) {
            // 如果子路径等于父路径，使用空字符串（这样完整路径就是父路径）
            routePath = ''
            fullPath = normalizedChildPath
            console.log(`[RouteBuilder] Level ${level}: 子路由路径等于父路径，使用空字符串: ${menu.path}`)
          } else {
            // 如果子路径是相对路径（不以 / 开头），直接使用
            if (!routePath.startsWith('/')) {
              // 相对路径，直接使用
              // 特殊情况：如果路径是 'index' 且父路径是 '/dashboard'，使用空字符串（这样完整路径就是 '/dashboard'）
              if (routePath === 'index' && normalizedParentPath === '/dashboard') {
                routePath = ''
                fullPath = normalizedParentPath
                console.log(`[RouteBuilder] Level ${level}: Dashboard 特殊处理，使用空路径: ${menu.path} (父: ${parentPath}) -> ${routePath} (完整路径: ${fullPath})`)
              } else {
                routePath = routePath || ''
                // 构建完整路径
                fullPath = normalizedParentPath ? `${normalizedParentPath}/${routePath}`.replace(/\/+/g, '/') : routePath
                // 如果 routePath 是空字符串，完整路径就是父路径
                if (!routePath) {
                  fullPath = normalizedParentPath
                }
                console.log(`[RouteBuilder] Level ${level}: 子路由使用相对路径: ${menu.path} (父: ${parentPath}) -> ${routePath} (完整路径: ${fullPath})`)
              }
            } else {
              // 如果子路径不以父路径开头，可能是数据错误，使用完整路径的最后一部分
              const pathParts = normalizedChildPath.split('/').filter(p => p)
              routePath = pathParts[pathParts.length - 1] || 'index'
              fullPath = normalizedChildPath
              console.warn(`[RouteBuilder] Level ${level}: 子路由路径 ${menu.path} 不以父路径 ${parentPath} 开头，使用路径最后部分: ${routePath}`)
            }
          }
        } else {
          // 没有父路径，说明是顶级菜单，使用完整路径
          fullPath = routePath.replace(/\/+$/, '')
        }
        
        // 生成路由名称
        let routeName = menu.name
        if (!routeName) {
          // 从完整路径生成名称：/system/user -> SystemUser
          routeName = fullPath
            .replace(/^\//, '') // 去掉开头的 /
            .split('/')
            .map(part => part.charAt(0).toUpperCase() + part.slice(1).replace(/-/g, ''))
            .join('')
          // 如果还是空的，使用路径的简化版本
          if (!routeName) {
            routeName = fullPath.replace(/\//g, '_').replace(/^_/, '').replace(/-/g, '_') || `route_${menu.id}`
          }
        }
        
        const route = {
          path: routePath, // 相对路径，用于 Vue Router
          name: routeName,
          component: componentLoader,
          meta: {
            title: menu.title,
            icon: menu.icon,
            keepAlive: menu.keep_alive === 1,
            fullPath: fullPath, // 保存完整路径到 meta 中，用于菜单导航
            originalPath: menu.path, // 保存原始路径，用于调试
          },
        }

        // 如果菜单有子菜单（3级菜单的情况），递归处理
        // 注意：这里传入的是完整路径（fullPath），而不是相对路径（routePath）
        if (menu.children && menu.children.length > 0 && level < maxLevel) {
          console.log(`[RouteBuilder] Level ${level}: 菜单 ${menu.path} 有子菜单，处理嵌套，使用完整路径: ${fullPath}`)
          const childrenRoutes = buildRoutes(menu.children, fullPath, level + 1)
          if (childrenRoutes.length > 0) {
            route.children = childrenRoutes
          }
        }

        console.log(`[RouteBuilder] Level ${level}: 构建菜单路由:`, {
          originalPath: menu.path,
          routePath: routePath,
          fullPath: fullPath,
          name: routeName,
          component: menu.component,
          parentPath: parentPath || 'none',
          hasChildren: route.children && route.children.length > 0
        })

        routeList.push(route)
      }
    })

    return routeList
  }

  // 查找第一个可用的路由（用于重定向）
  // 注意：这里需要构建完整路径，因为路由的 path 是相对路径
  const findFirstAvailableRoute = (routes, parentFullPath = '') => {
    for (const route of routes) {
      // 构建当前路由的完整路径
      let currentFullPath
      if (route.path.startsWith('/')) {
        // 绝对路径，直接使用
        currentFullPath = route.path
      } else if (route.path === '') {
        // 空字符串路径，完整路径就是父路径
        currentFullPath = parentFullPath || ''
      } else {
        // 相对路径，拼接父路径
        currentFullPath = parentFullPath 
          ? `${parentFullPath}/${route.path}`.replace(/\/+/g, '/')
          : route.path
      }
      
      // 如果路由有组件（不是目录），返回其完整路径
      if (route.component && route.component !== Layout) {
        return currentFullPath
      }
      // 如果路由有子路由，递归查找
      if (route.children && route.children.length > 0) {
        const childRoute = findFirstAvailableRoute(route.children, currentFullPath)
        if (childRoute) {
          return childRoute
        }
      }
    }
    return null
  }

  // 添加路由
  const addRoutes = (router) => {
    console.log('开始构建路由，菜单数据:', menus.value)
    const routeList = buildRoutes(menus.value)
    routes.value = routeList
    
    // 打印路由结构以便调试
    const printRoute = (route, indent = '') => {
      console.log(`${indent}${route.path} (${route.name || 'unnamed'}) - children: ${route.children ? route.children.length : 0}`)
      if (route.children && route.children.length > 0) {
        route.children.forEach(child => printRoute(child, indent + '  '))
      }
    }
    console.log('构建的路由列表:')
    routeList.forEach(route => printRoute(route))

    // 添加所有路由作为顶级路由（它们都有自己的Layout组件）
    routeList.forEach((route) => {
      // 检查路由是否已存在（通过路径或名称）
      const existingRouteByPath = router.getRoutes().find(r => r.path === route.path)
      const existingRouteByName = route.name ? router.getRoutes().find(r => r.name === route.name) : null
      
      // 如果路由已存在，先移除它（以便更新）
      if (existingRouteByName) {
        try {
          router.removeRoute(route.name)
          console.log(`[Router] 移除已存在的路由以便更新: ${route.name} (${route.path})`)
        } catch (error) {
          console.warn(`[Router] 移除路由失败: ${route.name}`, error)
        }
      } else if (existingRouteByPath && !route.name) {
        // 如果路由存在但没有名称，无法移除，只能跳过或警告
        console.warn(`[Router] 路由已存在但没有名称，无法更新: ${route.path}`)
      }
      
      const routeInfo = {
        path: route.path,
        name: route.name,
        hasChildren: route.children && route.children.length > 0,
        childrenCount: route.children ? route.children.length : 0,
      }
      
      if (route.children && route.children.length > 0) {
        routeInfo.children = route.children.map(c => {
          // 构建完整路径
          let childFullPath
          if (c.path.startsWith('/')) {
            childFullPath = c.path
          } else if (c.path === '') {
            // 空字符串路径，完整路径就是父路径
            childFullPath = route.path
          } else {
            childFullPath = `${route.path}/${c.path}`.replace(/\/+/g, '/')
          }
          return {
            path: c.path,
            name: c.name,
            fullPath: childFullPath
          }
        })
      }
      
      console.log(`[Router] 添加路由: ${route.path} (${route.name || 'unnamed'})`, routeInfo)
      
      // 直接添加路由（它们都有自己的Layout组件，所以不需要添加到根路由下）
      router.addRoute(route)
      
      // 验证路由是否正确添加
      const addedRoute = router.getRoutes().find(r => r.path === route.path || (route.name && r.name === route.name))
      if (addedRoute) {
        console.log(`[Router] 路由已成功添加: ${route.path}`, {
          hasChildren: addedRoute.children && addedRoute.children.length > 0,
          childrenCount: addedRoute.children ? addedRoute.children.length : 0
        })
      } else {
        console.error(`[Router] 路由添加失败: ${route.path}`)
      }
    })
    
    // 打印所有已注册的路由
    console.log('当前所有路由:')
    router.getRoutes().forEach(r => {
      console.log(`  ${r.path} (${r.name || 'unnamed'})`, {
        hasChildren: r.children && r.children.length > 0,
        children: r.children ? r.children.map(c => `${c.path} (${c.name || 'unnamed'})`) : []
      })
    })
  }

  // 刷新路由（重新加载菜单并更新路由）
  const refreshRoutes = async (router) => {
    try {
      console.log('开始刷新菜单路由...')
      
      // 保存当前路由列表（用于移除）
      const currentRoutes = router.getRoutes()
      const routeNamesToRemove = []
      
      // 收集所有动态路由的名称（保留静态路由）
      const staticRoutePaths = ['/login', '/']
      currentRoutes.forEach(route => {
        // 跳过静态路由和 404 路由
        if (staticRoutePaths.includes(route.path) || route.path.startsWith('/:')) {
          return
        }
        
        // 跳过根路由及其子路由（dashboard, profile 等）
        if (route.path === '/' || route.parent?.path === '/') {
          return
        }
        
        // 收集需要移除的路由名称
        if (route.name) {
          routeNamesToRemove.push(route.name)
        }
      })
      
      // 移除所有动态路由
      routeNamesToRemove.forEach(name => {
        try {
          router.removeRoute(name)
          console.log(`[Router] 移除路由: ${name}`)
        } catch (error) {
          console.warn(`[Router] 移除路由失败: ${name}`, error)
        }
      })
      
      // 清除旧的菜单数据
      menus.value = []
      routes.value = []
      
      // 重新获取菜单数据
      const menusData = await getMenus()
      
      if (menusData && menusData.length > 0) {
        // 重新添加路由
        addRoutes(router)
        console.log('菜单路由刷新完成')
        return true
      } else {
        console.warn('菜单数据为空，无法刷新路由')
        return false
      }
    } catch (error) {
      console.error('刷新菜单路由失败:', error)
      return false
    }
  }

  return {
    menus,
    routes,
    getMenus,
    addRoutes,
    refreshRoutes,
  }
})

